/*
 *  Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 *  This source code is licensed under the MIT license found in the LICENSE
 *  file in the root directory of this source tree.
 *
 */

/*
 *  THIS FILE IS AUTOGENERATED. DO NOT MODIFY IT; ALL CHANGES WILL BE LOST IN
 *  VAIN.
 *
 *  @generated
 */

namespace facebook {
namespace memcache {
namespace thrift {

template <class Writer>
void MemcacheRequestCommon::serialize(Writer&& writer) const {
  writer.writeStructBegin();
  writer.writeField(1 /* field id */, beforeLatencyUs_ref());
  writer.writeField(2 /* field id */, afterLatencyUs_ref());
  writer.writeField(3 /* field id */, bucketId_ref());
  writer.writeField(4 /* field id */, productId_ref());
  writer.writeFieldStop();
  writer.writeStructEnd();
}

template <class V>
void MemcacheRequestCommon::visitFields(V&& v) {
  if (!v.visitField(1, "beforeLatencyUs", this->beforeLatencyUs_ref())) {
    return;
  }
  if (!v.visitField(2, "afterLatencyUs", this->afterLatencyUs_ref())) {
    return;
  }
  if (!v.visitField(3, "bucketId", this->bucketId_ref())) {
    return;
  }
  if (!v.visitField(4, "productId", this->productId_ref())) {
    return;
  }
}

template <class V>
void MemcacheRequestCommon::visitFields(V&& v) const {
  if (!v.visitField(1, "beforeLatencyUs", this->beforeLatencyUs_ref())) {
    return;
  }
  if (!v.visitField(2, "afterLatencyUs", this->afterLatencyUs_ref())) {
    return;
  }
  if (!v.visitField(3, "bucketId", this->bucketId_ref())) {
    return;
  }
  if (!v.visitField(4, "productId", this->productId_ref())) {
    return;
  }
}

template <class Writer>
void MemcacheReplyCommon::serialize(Writer&& writer) const {
  writer.writeStructBegin();
  writer.writeField(1 /* field id */, replySourceBitMask_ref());
  writer.writeFieldStop();
  writer.writeStructEnd();
}

template <class V>
void MemcacheReplyCommon::visitFields(V&& v) {
  if (!v.visitField(1, "replySourceBitMask", *this->replySourceBitMask_ref())) {
    return;
  }
}

template <class V>
void MemcacheReplyCommon::visitFields(V&& v) const {
  if (!v.visitField(1, "replySourceBitMask", *this->replySourceBitMask_ref())) {
    return;
  }
}

template <class Writer>
void McGetRequest::serialize(Writer&& writer) const {
  writer.writeStructBegin();
  writer.writeField(-1 /* field id */, memcacheRequestCommon_ref());
  writer.writeField(1 /* field id */, key_ref());
  writer.writeField(2 /* field id */, flags_ref());
  writer.writeFieldStop();
  writer.writeStructEnd();
}

template <class V>
void McGetRequest::visitFields(V&& v) {
  if (v.enterMixin(1, "MemcacheRequestCommon", memcacheRequestCommon)) {
    this->memcacheRequestCommon.visitFields(std::forward<V>(v));
  }
  if (!v.leaveMixin()) {
    return;
  }
  if (!v.visitField(1, "key", *this->key_ref())) {
    return;
  }
  if (!v.visitField(2, "flags", *this->flags_ref())) {
    return;
  }
}

template <class V>
void McGetRequest::visitFields(V&& v) const {
  if (v.enterMixin(1, "MemcacheRequestCommon", memcacheRequestCommon)) {
    this->memcacheRequestCommon.visitFields(std::forward<V>(v));
  }
  if (!v.leaveMixin()) {
    return;
  }
  if (!v.visitField(1, "key", *this->key_ref())) {
    return;
  }
  if (!v.visitField(2, "flags", *this->flags_ref())) {
    return;
  }
}

template <class Writer>
void McGetReply::serialize(Writer&& writer) const {
  writer.writeStructBegin();
  writer.writeField(-1 /* field id */, memcacheReplyCommon_ref());
  writer.writeField(1 /* field id */, result_ref());
  writer.writeField(2 /* field id */, value_ref());
  writer.writeField(3 /* field id */, flags_ref());
  writer.writeField(4 /* field id */, message_ref());
  writer.writeField(5 /* field id */, appSpecificErrorCode_ref());
  writer.writeFieldStop();
  writer.writeStructEnd();
}

template <class V>
void McGetReply::visitFields(V&& v) {
  if (v.enterMixin(1, "MemcacheReplyCommon", memcacheReplyCommon)) {
    this->memcacheReplyCommon.visitFields(std::forward<V>(v));
  }
  if (!v.leaveMixin()) {
    return;
  }
  if (!v.visitField(1, "result", *this->result_ref())) {
    return;
  }
  if (!v.visitField(2, "value", this->value_ref())) {
    return;
  }
  if (!v.visitField(3, "flags", *this->flags_ref())) {
    return;
  }
  if (!v.visitField(4, "message", *this->message_ref())) {
    return;
  }
  if (!v.visitField(5, "appSpecificErrorCode", *this->appSpecificErrorCode_ref())) {
    return;
  }
}

template <class V>
void McGetReply::visitFields(V&& v) const {
  if (v.enterMixin(1, "MemcacheReplyCommon", memcacheReplyCommon)) {
    this->memcacheReplyCommon.visitFields(std::forward<V>(v));
  }
  if (!v.leaveMixin()) {
    return;
  }
  if (!v.visitField(1, "result", *this->result_ref())) {
    return;
  }
  if (!v.visitField(2, "value", this->value_ref())) {
    return;
  }
  if (!v.visitField(3, "flags", *this->flags_ref())) {
    return;
  }
  if (!v.visitField(4, "message", *this->message_ref())) {
    return;
  }
  if (!v.visitField(5, "appSpecificErrorCode", *this->appSpecificErrorCode_ref())) {
    return;
  }
}

template <class Writer>
void McSetRequest::serialize(Writer&& writer) const {
  writer.writeStructBegin();
  writer.writeField(-1 /* field id */, memcacheRequestCommon_ref());
  writer.writeField(1 /* field id */, key_ref());
  writer.writeField(2 /* field id */, exptime_ref());
  writer.writeField(3 /* field id */, flags_ref());
  writer.writeField(4 /* field id */, value_ref());
  writer.writeFieldStop();
  writer.writeStructEnd();
}

template <class V>
void McSetRequest::visitFields(V&& v) {
  if (v.enterMixin(1, "MemcacheRequestCommon", memcacheRequestCommon)) {
    this->memcacheRequestCommon.visitFields(std::forward<V>(v));
  }
  if (!v.leaveMixin()) {
    return;
  }
  if (!v.visitField(1, "key", *this->key_ref())) {
    return;
  }
  if (!v.visitField(2, "exptime", *this->exptime_ref())) {
    return;
  }
  if (!v.visitField(3, "flags", *this->flags_ref())) {
    return;
  }
  if (!v.visitField(4, "value", *this->value_ref())) {
    return;
  }
}

template <class V>
void McSetRequest::visitFields(V&& v) const {
  if (v.enterMixin(1, "MemcacheRequestCommon", memcacheRequestCommon)) {
    this->memcacheRequestCommon.visitFields(std::forward<V>(v));
  }
  if (!v.leaveMixin()) {
    return;
  }
  if (!v.visitField(1, "key", *this->key_ref())) {
    return;
  }
  if (!v.visitField(2, "exptime", *this->exptime_ref())) {
    return;
  }
  if (!v.visitField(3, "flags", *this->flags_ref())) {
    return;
  }
  if (!v.visitField(4, "value", *this->value_ref())) {
    return;
  }
}

template <class Writer>
void McSetReply::serialize(Writer&& writer) const {
  writer.writeStructBegin();
  writer.writeField(-1 /* field id */, memcacheReplyCommon_ref());
  writer.writeField(1 /* field id */, result_ref());
  writer.writeField(2 /* field id */, flags_ref());
  writer.writeField(3 /* field id */, value_ref());
  writer.writeField(4 /* field id */, message_ref());
  writer.writeField(5 /* field id */, appSpecificErrorCode_ref());
  writer.writeFieldStop();
  writer.writeStructEnd();
}

template <class V>
void McSetReply::visitFields(V&& v) {
  if (v.enterMixin(1, "MemcacheReplyCommon", memcacheReplyCommon)) {
    this->memcacheReplyCommon.visitFields(std::forward<V>(v));
  }
  if (!v.leaveMixin()) {
    return;
  }
  if (!v.visitField(1, "result", *this->result_ref())) {
    return;
  }
  if (!v.visitField(2, "flags", *this->flags_ref())) {
    return;
  }
  if (!v.visitField(3, "value", *this->value_ref())) {
    return;
  }
  if (!v.visitField(4, "message", *this->message_ref())) {
    return;
  }
  if (!v.visitField(5, "appSpecificErrorCode", *this->appSpecificErrorCode_ref())) {
    return;
  }
}

template <class V>
void McSetReply::visitFields(V&& v) const {
  if (v.enterMixin(1, "MemcacheReplyCommon", memcacheReplyCommon)) {
    this->memcacheReplyCommon.visitFields(std::forward<V>(v));
  }
  if (!v.leaveMixin()) {
    return;
  }
  if (!v.visitField(1, "result", *this->result_ref())) {
    return;
  }
  if (!v.visitField(2, "flags", *this->flags_ref())) {
    return;
  }
  if (!v.visitField(3, "value", *this->value_ref())) {
    return;
  }
  if (!v.visitField(4, "message", *this->message_ref())) {
    return;
  }
  if (!v.visitField(5, "appSpecificErrorCode", *this->appSpecificErrorCode_ref())) {
    return;
  }
}

template <class Writer>
void McDeleteRequest::serialize(Writer&& writer) const {
  writer.writeStructBegin();
  writer.writeField(-1 /* field id */, memcacheRequestCommon_ref());
  writer.writeField(1 /* field id */, key_ref());
  writer.writeField(2 /* field id */, flags_ref());
  writer.writeField(3 /* field id */, exptime_ref());
  writer.writeField(4 /* field id */, value_ref());
  writer.writeField(5 /* field id */, attributes_ref());
  writer.writeFieldStop();
  writer.writeStructEnd();
}

template <class V>
void McDeleteRequest::visitFields(V&& v) {
  if (v.enterMixin(1, "MemcacheRequestCommon", memcacheRequestCommon)) {
    this->memcacheRequestCommon.visitFields(std::forward<V>(v));
  }
  if (!v.leaveMixin()) {
    return;
  }
  if (!v.visitField(1, "key", *this->key_ref())) {
    return;
  }
  if (!v.visitField(2, "flags", *this->flags_ref())) {
    return;
  }
  if (!v.visitField(3, "exptime", *this->exptime_ref())) {
    return;
  }
  if (!v.visitField(4, "value", *this->value_ref())) {
    return;
  }
  if (!v.visitField(5, "attributes", *this->attributes_ref())) {
    return;
  }
}

template <class V>
void McDeleteRequest::visitFields(V&& v) const {
  if (v.enterMixin(1, "MemcacheRequestCommon", memcacheRequestCommon)) {
    this->memcacheRequestCommon.visitFields(std::forward<V>(v));
  }
  if (!v.leaveMixin()) {
    return;
  }
  if (!v.visitField(1, "key", *this->key_ref())) {
    return;
  }
  if (!v.visitField(2, "flags", *this->flags_ref())) {
    return;
  }
  if (!v.visitField(3, "exptime", *this->exptime_ref())) {
    return;
  }
  if (!v.visitField(4, "value", *this->value_ref())) {
    return;
  }
  if (!v.visitField(5, "attributes", *this->attributes_ref())) {
    return;
  }
}

template <class Writer>
void McDeleteReply::serialize(Writer&& writer) const {
  writer.writeStructBegin();
  writer.writeField(-1 /* field id */, memcacheReplyCommon_ref());
  writer.writeField(1 /* field id */, result_ref());
  writer.writeField(2 /* field id */, flags_ref());
  writer.writeField(3 /* field id */, value_ref());
  writer.writeField(4 /* field id */, message_ref());
  writer.writeField(5 /* field id */, appSpecificErrorCode_ref());
  writer.writeFieldStop();
  writer.writeStructEnd();
}

template <class V>
void McDeleteReply::visitFields(V&& v) {
  if (v.enterMixin(1, "MemcacheReplyCommon", memcacheReplyCommon)) {
    this->memcacheReplyCommon.visitFields(std::forward<V>(v));
  }
  if (!v.leaveMixin()) {
    return;
  }
  if (!v.visitField(1, "result", *this->result_ref())) {
    return;
  }
  if (!v.visitField(2, "flags", *this->flags_ref())) {
    return;
  }
  if (!v.visitField(3, "value", *this->value_ref())) {
    return;
  }
  if (!v.visitField(4, "message", *this->message_ref())) {
    return;
  }
  if (!v.visitField(5, "appSpecificErrorCode", *this->appSpecificErrorCode_ref())) {
    return;
  }
}

template <class V>
void McDeleteReply::visitFields(V&& v) const {
  if (v.enterMixin(1, "MemcacheReplyCommon", memcacheReplyCommon)) {
    this->memcacheReplyCommon.visitFields(std::forward<V>(v));
  }
  if (!v.leaveMixin()) {
    return;
  }
  if (!v.visitField(1, "result", *this->result_ref())) {
    return;
  }
  if (!v.visitField(2, "flags", *this->flags_ref())) {
    return;
  }
  if (!v.visitField(3, "value", *this->value_ref())) {
    return;
  }
  if (!v.visitField(4, "message", *this->message_ref())) {
    return;
  }
  if (!v.visitField(5, "appSpecificErrorCode", *this->appSpecificErrorCode_ref())) {
    return;
  }
}

template <class Writer>
void McLeaseGetRequest::serialize(Writer&& writer) const {
  writer.writeStructBegin();
  writer.writeField(-1 /* field id */, memcacheRequestCommon_ref());
  writer.writeField(1 /* field id */, key_ref());
  writer.writeField(2 /* field id */, flags_ref());
  writer.writeFieldStop();
  writer.writeStructEnd();
}

template <class V>
void McLeaseGetRequest::visitFields(V&& v) {
  if (v.enterMixin(1, "MemcacheRequestCommon", memcacheRequestCommon)) {
    this->memcacheRequestCommon.visitFields(std::forward<V>(v));
  }
  if (!v.leaveMixin()) {
    return;
  }
  if (!v.visitField(1, "key", *this->key_ref())) {
    return;
  }
  if (!v.visitField(2, "flags", *this->flags_ref())) {
    return;
  }
}

template <class V>
void McLeaseGetRequest::visitFields(V&& v) const {
  if (v.enterMixin(1, "MemcacheRequestCommon", memcacheRequestCommon)) {
    this->memcacheRequestCommon.visitFields(std::forward<V>(v));
  }
  if (!v.leaveMixin()) {
    return;
  }
  if (!v.visitField(1, "key", *this->key_ref())) {
    return;
  }
  if (!v.visitField(2, "flags", *this->flags_ref())) {
    return;
  }
}

template <class Writer>
void McLeaseGetReply::serialize(Writer&& writer) const {
  writer.writeStructBegin();
  writer.writeField(-1 /* field id */, memcacheReplyCommon_ref());
  writer.writeField(1 /* field id */, result_ref());
  writer.writeField(2 /* field id */, leaseToken_ref());
  writer.writeField(3 /* field id */, value_ref());
  writer.writeField(4 /* field id */, flags_ref());
  writer.writeField(5 /* field id */, message_ref());
  writer.writeField(6 /* field id */, appSpecificErrorCode_ref());
  writer.writeFieldStop();
  writer.writeStructEnd();
}

template <class V>
void McLeaseGetReply::visitFields(V&& v) {
  if (v.enterMixin(1, "MemcacheReplyCommon", memcacheReplyCommon)) {
    this->memcacheReplyCommon.visitFields(std::forward<V>(v));
  }
  if (!v.leaveMixin()) {
    return;
  }
  if (!v.visitField(1, "result", *this->result_ref())) {
    return;
  }
  if (!v.visitField(2, "leaseToken", *this->leaseToken_ref())) {
    return;
  }
  if (!v.visitField(3, "value", this->value_ref())) {
    return;
  }
  if (!v.visitField(4, "flags", *this->flags_ref())) {
    return;
  }
  if (!v.visitField(5, "message", *this->message_ref())) {
    return;
  }
  if (!v.visitField(6, "appSpecificErrorCode", *this->appSpecificErrorCode_ref())) {
    return;
  }
}

template <class V>
void McLeaseGetReply::visitFields(V&& v) const {
  if (v.enterMixin(1, "MemcacheReplyCommon", memcacheReplyCommon)) {
    this->memcacheReplyCommon.visitFields(std::forward<V>(v));
  }
  if (!v.leaveMixin()) {
    return;
  }
  if (!v.visitField(1, "result", *this->result_ref())) {
    return;
  }
  if (!v.visitField(2, "leaseToken", *this->leaseToken_ref())) {
    return;
  }
  if (!v.visitField(3, "value", this->value_ref())) {
    return;
  }
  if (!v.visitField(4, "flags", *this->flags_ref())) {
    return;
  }
  if (!v.visitField(5, "message", *this->message_ref())) {
    return;
  }
  if (!v.visitField(6, "appSpecificErrorCode", *this->appSpecificErrorCode_ref())) {
    return;
  }
}

template <class Writer>
void McLeaseSetRequest::serialize(Writer&& writer) const {
  writer.writeStructBegin();
  writer.writeField(-1 /* field id */, memcacheRequestCommon_ref());
  writer.writeField(1 /* field id */, key_ref());
  writer.writeField(2 /* field id */, exptime_ref());
  writer.writeField(3 /* field id */, flags_ref());
  writer.writeField(4 /* field id */, value_ref());
  writer.writeField(5 /* field id */, leaseToken_ref());
  writer.writeFieldStop();
  writer.writeStructEnd();
}

template <class V>
void McLeaseSetRequest::visitFields(V&& v) {
  if (v.enterMixin(1, "MemcacheRequestCommon", memcacheRequestCommon)) {
    this->memcacheRequestCommon.visitFields(std::forward<V>(v));
  }
  if (!v.leaveMixin()) {
    return;
  }
  if (!v.visitField(1, "key", *this->key_ref())) {
    return;
  }
  if (!v.visitField(2, "exptime", *this->exptime_ref())) {
    return;
  }
  if (!v.visitField(3, "flags", *this->flags_ref())) {
    return;
  }
  if (!v.visitField(4, "value", *this->value_ref())) {
    return;
  }
  if (!v.visitField(5, "leaseToken", *this->leaseToken_ref())) {
    return;
  }
}

template <class V>
void McLeaseSetRequest::visitFields(V&& v) const {
  if (v.enterMixin(1, "MemcacheRequestCommon", memcacheRequestCommon)) {
    this->memcacheRequestCommon.visitFields(std::forward<V>(v));
  }
  if (!v.leaveMixin()) {
    return;
  }
  if (!v.visitField(1, "key", *this->key_ref())) {
    return;
  }
  if (!v.visitField(2, "exptime", *this->exptime_ref())) {
    return;
  }
  if (!v.visitField(3, "flags", *this->flags_ref())) {
    return;
  }
  if (!v.visitField(4, "value", *this->value_ref())) {
    return;
  }
  if (!v.visitField(5, "leaseToken", *this->leaseToken_ref())) {
    return;
  }
}

template <class Writer>
void McLeaseSetReply::serialize(Writer&& writer) const {
  writer.writeStructBegin();
  writer.writeField(-1 /* field id */, memcacheReplyCommon_ref());
  writer.writeField(1 /* field id */, result_ref());
  writer.writeField(2 /* field id */, message_ref());
  writer.writeField(3 /* field id */, appSpecificErrorCode_ref());
  writer.writeFieldStop();
  writer.writeStructEnd();
}

template <class V>
void McLeaseSetReply::visitFields(V&& v) {
  if (v.enterMixin(1, "MemcacheReplyCommon", memcacheReplyCommon)) {
    this->memcacheReplyCommon.visitFields(std::forward<V>(v));
  }
  if (!v.leaveMixin()) {
    return;
  }
  if (!v.visitField(1, "result", *this->result_ref())) {
    return;
  }
  if (!v.visitField(2, "message", *this->message_ref())) {
    return;
  }
  if (!v.visitField(3, "appSpecificErrorCode", *this->appSpecificErrorCode_ref())) {
    return;
  }
}

template <class V>
void McLeaseSetReply::visitFields(V&& v) const {
  if (v.enterMixin(1, "MemcacheReplyCommon", memcacheReplyCommon)) {
    this->memcacheReplyCommon.visitFields(std::forward<V>(v));
  }
  if (!v.leaveMixin()) {
    return;
  }
  if (!v.visitField(1, "result", *this->result_ref())) {
    return;
  }
  if (!v.visitField(2, "message", *this->message_ref())) {
    return;
  }
  if (!v.visitField(3, "appSpecificErrorCode", *this->appSpecificErrorCode_ref())) {
    return;
  }
}

template <class Writer>
void McAddRequest::serialize(Writer&& writer) const {
  writer.writeStructBegin();
  writer.writeField(-1 /* field id */, memcacheRequestCommon_ref());
  writer.writeField(1 /* field id */, key_ref());
  writer.writeField(2 /* field id */, exptime_ref());
  writer.writeField(3 /* field id */, flags_ref());
  writer.writeField(4 /* field id */, value_ref());
  writer.writeFieldStop();
  writer.writeStructEnd();
}

template <class V>
void McAddRequest::visitFields(V&& v) {
  if (v.enterMixin(1, "MemcacheRequestCommon", memcacheRequestCommon)) {
    this->memcacheRequestCommon.visitFields(std::forward<V>(v));
  }
  if (!v.leaveMixin()) {
    return;
  }
  if (!v.visitField(1, "key", *this->key_ref())) {
    return;
  }
  if (!v.visitField(2, "exptime", *this->exptime_ref())) {
    return;
  }
  if (!v.visitField(3, "flags", *this->flags_ref())) {
    return;
  }
  if (!v.visitField(4, "value", *this->value_ref())) {
    return;
  }
}

template <class V>
void McAddRequest::visitFields(V&& v) const {
  if (v.enterMixin(1, "MemcacheRequestCommon", memcacheRequestCommon)) {
    this->memcacheRequestCommon.visitFields(std::forward<V>(v));
  }
  if (!v.leaveMixin()) {
    return;
  }
  if (!v.visitField(1, "key", *this->key_ref())) {
    return;
  }
  if (!v.visitField(2, "exptime", *this->exptime_ref())) {
    return;
  }
  if (!v.visitField(3, "flags", *this->flags_ref())) {
    return;
  }
  if (!v.visitField(4, "value", *this->value_ref())) {
    return;
  }
}

template <class Writer>
void McAddReply::serialize(Writer&& writer) const {
  writer.writeStructBegin();
  writer.writeField(-1 /* field id */, memcacheReplyCommon_ref());
  writer.writeField(1 /* field id */, result_ref());
  writer.writeField(2 /* field id */, message_ref());
  writer.writeField(3 /* field id */, appSpecificErrorCode_ref());
  writer.writeFieldStop();
  writer.writeStructEnd();
}

template <class V>
void McAddReply::visitFields(V&& v) {
  if (v.enterMixin(1, "MemcacheReplyCommon", memcacheReplyCommon)) {
    this->memcacheReplyCommon.visitFields(std::forward<V>(v));
  }
  if (!v.leaveMixin()) {
    return;
  }
  if (!v.visitField(1, "result", *this->result_ref())) {
    return;
  }
  if (!v.visitField(2, "message", *this->message_ref())) {
    return;
  }
  if (!v.visitField(3, "appSpecificErrorCode", *this->appSpecificErrorCode_ref())) {
    return;
  }
}

template <class V>
void McAddReply::visitFields(V&& v) const {
  if (v.enterMixin(1, "MemcacheReplyCommon", memcacheReplyCommon)) {
    this->memcacheReplyCommon.visitFields(std::forward<V>(v));
  }
  if (!v.leaveMixin()) {
    return;
  }
  if (!v.visitField(1, "result", *this->result_ref())) {
    return;
  }
  if (!v.visitField(2, "message", *this->message_ref())) {
    return;
  }
  if (!v.visitField(3, "appSpecificErrorCode", *this->appSpecificErrorCode_ref())) {
    return;
  }
}

template <class Writer>
void McReplaceRequest::serialize(Writer&& writer) const {
  writer.writeStructBegin();
  writer.writeField(-1 /* field id */, memcacheRequestCommon_ref());
  writer.writeField(1 /* field id */, key_ref());
  writer.writeField(2 /* field id */, exptime_ref());
  writer.writeField(3 /* field id */, flags_ref());
  writer.writeField(4 /* field id */, value_ref());
  writer.writeFieldStop();
  writer.writeStructEnd();
}

template <class V>
void McReplaceRequest::visitFields(V&& v) {
  if (v.enterMixin(1, "MemcacheRequestCommon", memcacheRequestCommon)) {
    this->memcacheRequestCommon.visitFields(std::forward<V>(v));
  }
  if (!v.leaveMixin()) {
    return;
  }
  if (!v.visitField(1, "key", *this->key_ref())) {
    return;
  }
  if (!v.visitField(2, "exptime", *this->exptime_ref())) {
    return;
  }
  if (!v.visitField(3, "flags", *this->flags_ref())) {
    return;
  }
  if (!v.visitField(4, "value", *this->value_ref())) {
    return;
  }
}

template <class V>
void McReplaceRequest::visitFields(V&& v) const {
  if (v.enterMixin(1, "MemcacheRequestCommon", memcacheRequestCommon)) {
    this->memcacheRequestCommon.visitFields(std::forward<V>(v));
  }
  if (!v.leaveMixin()) {
    return;
  }
  if (!v.visitField(1, "key", *this->key_ref())) {
    return;
  }
  if (!v.visitField(2, "exptime", *this->exptime_ref())) {
    return;
  }
  if (!v.visitField(3, "flags", *this->flags_ref())) {
    return;
  }
  if (!v.visitField(4, "value", *this->value_ref())) {
    return;
  }
}

template <class Writer>
void McReplaceReply::serialize(Writer&& writer) const {
  writer.writeStructBegin();
  writer.writeField(-1 /* field id */, memcacheReplyCommon_ref());
  writer.writeField(1 /* field id */, result_ref());
  writer.writeField(2 /* field id */, message_ref());
  writer.writeField(3 /* field id */, appSpecificErrorCode_ref());
  writer.writeFieldStop();
  writer.writeStructEnd();
}

template <class V>
void McReplaceReply::visitFields(V&& v) {
  if (v.enterMixin(1, "MemcacheReplyCommon", memcacheReplyCommon)) {
    this->memcacheReplyCommon.visitFields(std::forward<V>(v));
  }
  if (!v.leaveMixin()) {
    return;
  }
  if (!v.visitField(1, "result", *this->result_ref())) {
    return;
  }
  if (!v.visitField(2, "message", *this->message_ref())) {
    return;
  }
  if (!v.visitField(3, "appSpecificErrorCode", *this->appSpecificErrorCode_ref())) {
    return;
  }
}

template <class V>
void McReplaceReply::visitFields(V&& v) const {
  if (v.enterMixin(1, "MemcacheReplyCommon", memcacheReplyCommon)) {
    this->memcacheReplyCommon.visitFields(std::forward<V>(v));
  }
  if (!v.leaveMixin()) {
    return;
  }
  if (!v.visitField(1, "result", *this->result_ref())) {
    return;
  }
  if (!v.visitField(2, "message", *this->message_ref())) {
    return;
  }
  if (!v.visitField(3, "appSpecificErrorCode", *this->appSpecificErrorCode_ref())) {
    return;
  }
}

template <class Writer>
void McGetsRequest::serialize(Writer&& writer) const {
  writer.writeStructBegin();
  writer.writeField(-1 /* field id */, memcacheRequestCommon_ref());
  writer.writeField(1 /* field id */, key_ref());
  writer.writeField(2 /* field id */, flags_ref());
  writer.writeFieldStop();
  writer.writeStructEnd();
}

template <class V>
void McGetsRequest::visitFields(V&& v) {
  if (v.enterMixin(1, "MemcacheRequestCommon", memcacheRequestCommon)) {
    this->memcacheRequestCommon.visitFields(std::forward<V>(v));
  }
  if (!v.leaveMixin()) {
    return;
  }
  if (!v.visitField(1, "key", *this->key_ref())) {
    return;
  }
  if (!v.visitField(2, "flags", *this->flags_ref())) {
    return;
  }
}

template <class V>
void McGetsRequest::visitFields(V&& v) const {
  if (v.enterMixin(1, "MemcacheRequestCommon", memcacheRequestCommon)) {
    this->memcacheRequestCommon.visitFields(std::forward<V>(v));
  }
  if (!v.leaveMixin()) {
    return;
  }
  if (!v.visitField(1, "key", *this->key_ref())) {
    return;
  }
  if (!v.visitField(2, "flags", *this->flags_ref())) {
    return;
  }
}

template <class Writer>
void McGetsReply::serialize(Writer&& writer) const {
  writer.writeStructBegin();
  writer.writeField(-1 /* field id */, memcacheReplyCommon_ref());
  writer.writeField(1 /* field id */, result_ref());
  writer.writeField(2 /* field id */, casToken_ref());
  writer.writeField(3 /* field id */, value_ref());
  writer.writeField(4 /* field id */, flags_ref());
  writer.writeField(5 /* field id */, message_ref());
  writer.writeField(6 /* field id */, appSpecificErrorCode_ref());
  writer.writeFieldStop();
  writer.writeStructEnd();
}

template <class V>
void McGetsReply::visitFields(V&& v) {
  if (v.enterMixin(1, "MemcacheReplyCommon", memcacheReplyCommon)) {
    this->memcacheReplyCommon.visitFields(std::forward<V>(v));
  }
  if (!v.leaveMixin()) {
    return;
  }
  if (!v.visitField(1, "result", *this->result_ref())) {
    return;
  }
  if (!v.visitField(2, "casToken", *this->casToken_ref())) {
    return;
  }
  if (!v.visitField(3, "value", this->value_ref())) {
    return;
  }
  if (!v.visitField(4, "flags", *this->flags_ref())) {
    return;
  }
  if (!v.visitField(5, "message", *this->message_ref())) {
    return;
  }
  if (!v.visitField(6, "appSpecificErrorCode", *this->appSpecificErrorCode_ref())) {
    return;
  }
}

template <class V>
void McGetsReply::visitFields(V&& v) const {
  if (v.enterMixin(1, "MemcacheReplyCommon", memcacheReplyCommon)) {
    this->memcacheReplyCommon.visitFields(std::forward<V>(v));
  }
  if (!v.leaveMixin()) {
    return;
  }
  if (!v.visitField(1, "result", *this->result_ref())) {
    return;
  }
  if (!v.visitField(2, "casToken", *this->casToken_ref())) {
    return;
  }
  if (!v.visitField(3, "value", this->value_ref())) {
    return;
  }
  if (!v.visitField(4, "flags", *this->flags_ref())) {
    return;
  }
  if (!v.visitField(5, "message", *this->message_ref())) {
    return;
  }
  if (!v.visitField(6, "appSpecificErrorCode", *this->appSpecificErrorCode_ref())) {
    return;
  }
}

template <class Writer>
void McCasRequest::serialize(Writer&& writer) const {
  writer.writeStructBegin();
  writer.writeField(-1 /* field id */, memcacheRequestCommon_ref());
  writer.writeField(1 /* field id */, key_ref());
  writer.writeField(2 /* field id */, exptime_ref());
  writer.writeField(3 /* field id */, flags_ref());
  writer.writeField(4 /* field id */, value_ref());
  writer.writeField(5 /* field id */, casToken_ref());
  writer.writeFieldStop();
  writer.writeStructEnd();
}

template <class V>
void McCasRequest::visitFields(V&& v) {
  if (v.enterMixin(1, "MemcacheRequestCommon", memcacheRequestCommon)) {
    this->memcacheRequestCommon.visitFields(std::forward<V>(v));
  }
  if (!v.leaveMixin()) {
    return;
  }
  if (!v.visitField(1, "key", *this->key_ref())) {
    return;
  }
  if (!v.visitField(2, "exptime", *this->exptime_ref())) {
    return;
  }
  if (!v.visitField(3, "flags", *this->flags_ref())) {
    return;
  }
  if (!v.visitField(4, "value", *this->value_ref())) {
    return;
  }
  if (!v.visitField(5, "casToken", *this->casToken_ref())) {
    return;
  }
}

template <class V>
void McCasRequest::visitFields(V&& v) const {
  if (v.enterMixin(1, "MemcacheRequestCommon", memcacheRequestCommon)) {
    this->memcacheRequestCommon.visitFields(std::forward<V>(v));
  }
  if (!v.leaveMixin()) {
    return;
  }
  if (!v.visitField(1, "key", *this->key_ref())) {
    return;
  }
  if (!v.visitField(2, "exptime", *this->exptime_ref())) {
    return;
  }
  if (!v.visitField(3, "flags", *this->flags_ref())) {
    return;
  }
  if (!v.visitField(4, "value", *this->value_ref())) {
    return;
  }
  if (!v.visitField(5, "casToken", *this->casToken_ref())) {
    return;
  }
}

template <class Writer>
void McCasReply::serialize(Writer&& writer) const {
  writer.writeStructBegin();
  writer.writeField(-1 /* field id */, memcacheReplyCommon_ref());
  writer.writeField(1 /* field id */, result_ref());
  writer.writeField(2 /* field id */, message_ref());
  writer.writeField(3 /* field id */, appSpecificErrorCode_ref());
  writer.writeFieldStop();
  writer.writeStructEnd();
}

template <class V>
void McCasReply::visitFields(V&& v) {
  if (v.enterMixin(1, "MemcacheReplyCommon", memcacheReplyCommon)) {
    this->memcacheReplyCommon.visitFields(std::forward<V>(v));
  }
  if (!v.leaveMixin()) {
    return;
  }
  if (!v.visitField(1, "result", *this->result_ref())) {
    return;
  }
  if (!v.visitField(2, "message", *this->message_ref())) {
    return;
  }
  if (!v.visitField(3, "appSpecificErrorCode", *this->appSpecificErrorCode_ref())) {
    return;
  }
}

template <class V>
void McCasReply::visitFields(V&& v) const {
  if (v.enterMixin(1, "MemcacheReplyCommon", memcacheReplyCommon)) {
    this->memcacheReplyCommon.visitFields(std::forward<V>(v));
  }
  if (!v.leaveMixin()) {
    return;
  }
  if (!v.visitField(1, "result", *this->result_ref())) {
    return;
  }
  if (!v.visitField(2, "message", *this->message_ref())) {
    return;
  }
  if (!v.visitField(3, "appSpecificErrorCode", *this->appSpecificErrorCode_ref())) {
    return;
  }
}

template <class Writer>
void McIncrRequest::serialize(Writer&& writer) const {
  writer.writeStructBegin();
  writer.writeField(-1 /* field id */, memcacheRequestCommon_ref());
  writer.writeField(1 /* field id */, key_ref());
  writer.writeField(2 /* field id */, delta_ref());
  writer.writeFieldStop();
  writer.writeStructEnd();
}

template <class V>
void McIncrRequest::visitFields(V&& v) {
  if (v.enterMixin(1, "MemcacheRequestCommon", memcacheRequestCommon)) {
    this->memcacheRequestCommon.visitFields(std::forward<V>(v));
  }
  if (!v.leaveMixin()) {
    return;
  }
  if (!v.visitField(1, "key", *this->key_ref())) {
    return;
  }
  if (!v.visitField(2, "delta", *this->delta_ref())) {
    return;
  }
}

template <class V>
void McIncrRequest::visitFields(V&& v) const {
  if (v.enterMixin(1, "MemcacheRequestCommon", memcacheRequestCommon)) {
    this->memcacheRequestCommon.visitFields(std::forward<V>(v));
  }
  if (!v.leaveMixin()) {
    return;
  }
  if (!v.visitField(1, "key", *this->key_ref())) {
    return;
  }
  if (!v.visitField(2, "delta", *this->delta_ref())) {
    return;
  }
}

template <class Writer>
void McIncrReply::serialize(Writer&& writer) const {
  writer.writeStructBegin();
  writer.writeField(-1 /* field id */, memcacheReplyCommon_ref());
  writer.writeField(1 /* field id */, result_ref());
  writer.writeField(2 /* field id */, delta_ref());
  writer.writeField(3 /* field id */, message_ref());
  writer.writeField(4 /* field id */, appSpecificErrorCode_ref());
  writer.writeFieldStop();
  writer.writeStructEnd();
}

template <class V>
void McIncrReply::visitFields(V&& v) {
  if (v.enterMixin(1, "MemcacheReplyCommon", memcacheReplyCommon)) {
    this->memcacheReplyCommon.visitFields(std::forward<V>(v));
  }
  if (!v.leaveMixin()) {
    return;
  }
  if (!v.visitField(1, "result", *this->result_ref())) {
    return;
  }
  if (!v.visitField(2, "delta", *this->delta_ref())) {
    return;
  }
  if (!v.visitField(3, "message", *this->message_ref())) {
    return;
  }
  if (!v.visitField(4, "appSpecificErrorCode", *this->appSpecificErrorCode_ref())) {
    return;
  }
}

template <class V>
void McIncrReply::visitFields(V&& v) const {
  if (v.enterMixin(1, "MemcacheReplyCommon", memcacheReplyCommon)) {
    this->memcacheReplyCommon.visitFields(std::forward<V>(v));
  }
  if (!v.leaveMixin()) {
    return;
  }
  if (!v.visitField(1, "result", *this->result_ref())) {
    return;
  }
  if (!v.visitField(2, "delta", *this->delta_ref())) {
    return;
  }
  if (!v.visitField(3, "message", *this->message_ref())) {
    return;
  }
  if (!v.visitField(4, "appSpecificErrorCode", *this->appSpecificErrorCode_ref())) {
    return;
  }
}

template <class Writer>
void McDecrRequest::serialize(Writer&& writer) const {
  writer.writeStructBegin();
  writer.writeField(-1 /* field id */, memcacheRequestCommon_ref());
  writer.writeField(1 /* field id */, key_ref());
  writer.writeField(2 /* field id */, delta_ref());
  writer.writeFieldStop();
  writer.writeStructEnd();
}

template <class V>
void McDecrRequest::visitFields(V&& v) {
  if (v.enterMixin(1, "MemcacheRequestCommon", memcacheRequestCommon)) {
    this->memcacheRequestCommon.visitFields(std::forward<V>(v));
  }
  if (!v.leaveMixin()) {
    return;
  }
  if (!v.visitField(1, "key", *this->key_ref())) {
    return;
  }
  if (!v.visitField(2, "delta", *this->delta_ref())) {
    return;
  }
}

template <class V>
void McDecrRequest::visitFields(V&& v) const {
  if (v.enterMixin(1, "MemcacheRequestCommon", memcacheRequestCommon)) {
    this->memcacheRequestCommon.visitFields(std::forward<V>(v));
  }
  if (!v.leaveMixin()) {
    return;
  }
  if (!v.visitField(1, "key", *this->key_ref())) {
    return;
  }
  if (!v.visitField(2, "delta", *this->delta_ref())) {
    return;
  }
}

template <class Writer>
void McDecrReply::serialize(Writer&& writer) const {
  writer.writeStructBegin();
  writer.writeField(-1 /* field id */, memcacheReplyCommon_ref());
  writer.writeField(1 /* field id */, result_ref());
  writer.writeField(2 /* field id */, delta_ref());
  writer.writeField(3 /* field id */, message_ref());
  writer.writeField(4 /* field id */, appSpecificErrorCode_ref());
  writer.writeFieldStop();
  writer.writeStructEnd();
}

template <class V>
void McDecrReply::visitFields(V&& v) {
  if (v.enterMixin(1, "MemcacheReplyCommon", memcacheReplyCommon)) {
    this->memcacheReplyCommon.visitFields(std::forward<V>(v));
  }
  if (!v.leaveMixin()) {
    return;
  }
  if (!v.visitField(1, "result", *this->result_ref())) {
    return;
  }
  if (!v.visitField(2, "delta", *this->delta_ref())) {
    return;
  }
  if (!v.visitField(3, "message", *this->message_ref())) {
    return;
  }
  if (!v.visitField(4, "appSpecificErrorCode", *this->appSpecificErrorCode_ref())) {
    return;
  }
}

template <class V>
void McDecrReply::visitFields(V&& v) const {
  if (v.enterMixin(1, "MemcacheReplyCommon", memcacheReplyCommon)) {
    this->memcacheReplyCommon.visitFields(std::forward<V>(v));
  }
  if (!v.leaveMixin()) {
    return;
  }
  if (!v.visitField(1, "result", *this->result_ref())) {
    return;
  }
  if (!v.visitField(2, "delta", *this->delta_ref())) {
    return;
  }
  if (!v.visitField(3, "message", *this->message_ref())) {
    return;
  }
  if (!v.visitField(4, "appSpecificErrorCode", *this->appSpecificErrorCode_ref())) {
    return;
  }
}

template <class Writer>
void McMetagetRequest::serialize(Writer&& writer) const {
  writer.writeStructBegin();
  writer.writeField(-1 /* field id */, memcacheRequestCommon_ref());
  writer.writeField(1 /* field id */, key_ref());
  writer.writeFieldStop();
  writer.writeStructEnd();
}

template <class V>
void McMetagetRequest::visitFields(V&& v) {
  if (v.enterMixin(1, "MemcacheRequestCommon", memcacheRequestCommon)) {
    this->memcacheRequestCommon.visitFields(std::forward<V>(v));
  }
  if (!v.leaveMixin()) {
    return;
  }
  if (!v.visitField(1, "key", *this->key_ref())) {
    return;
  }
}

template <class V>
void McMetagetRequest::visitFields(V&& v) const {
  if (v.enterMixin(1, "MemcacheRequestCommon", memcacheRequestCommon)) {
    this->memcacheRequestCommon.visitFields(std::forward<V>(v));
  }
  if (!v.leaveMixin()) {
    return;
  }
  if (!v.visitField(1, "key", *this->key_ref())) {
    return;
  }
}

template <class Writer>
void McMetagetReply::serialize(Writer&& writer) const {
  writer.writeStructBegin();
  writer.writeField(-1 /* field id */, memcacheReplyCommon_ref());
  writer.writeField(1 /* field id */, result_ref());
  writer.writeField(2 /* field id */, age_ref());
  writer.writeField(3 /* field id */, exptime_ref());
  writer.writeField(4 /* field id */, ipv_ref());
  writer.writeField(5 /* field id */, ipAddress_ref());
  writer.writeField(6 /* field id */, message_ref());
  writer.writeField(7 /* field id */, appSpecificErrorCode_ref());
  writer.writeFieldStop();
  writer.writeStructEnd();
}

template <class V>
void McMetagetReply::visitFields(V&& v) {
  if (v.enterMixin(1, "MemcacheReplyCommon", memcacheReplyCommon)) {
    this->memcacheReplyCommon.visitFields(std::forward<V>(v));
  }
  if (!v.leaveMixin()) {
    return;
  }
  if (!v.visitField(1, "result", *this->result_ref())) {
    return;
  }
  if (!v.visitField(2, "age", *this->age_ref())) {
    return;
  }
  if (!v.visitField(3, "exptime", *this->exptime_ref())) {
    return;
  }
  if (!v.visitField(4, "ipv", *this->ipv_ref())) {
    return;
  }
  if (!v.visitField(5, "ipAddress", *this->ipAddress_ref())) {
    return;
  }
  if (!v.visitField(6, "message", *this->message_ref())) {
    return;
  }
  if (!v.visitField(7, "appSpecificErrorCode", *this->appSpecificErrorCode_ref())) {
    return;
  }
}

template <class V>
void McMetagetReply::visitFields(V&& v) const {
  if (v.enterMixin(1, "MemcacheReplyCommon", memcacheReplyCommon)) {
    this->memcacheReplyCommon.visitFields(std::forward<V>(v));
  }
  if (!v.leaveMixin()) {
    return;
  }
  if (!v.visitField(1, "result", *this->result_ref())) {
    return;
  }
  if (!v.visitField(2, "age", *this->age_ref())) {
    return;
  }
  if (!v.visitField(3, "exptime", *this->exptime_ref())) {
    return;
  }
  if (!v.visitField(4, "ipv", *this->ipv_ref())) {
    return;
  }
  if (!v.visitField(5, "ipAddress", *this->ipAddress_ref())) {
    return;
  }
  if (!v.visitField(6, "message", *this->message_ref())) {
    return;
  }
  if (!v.visitField(7, "appSpecificErrorCode", *this->appSpecificErrorCode_ref())) {
    return;
  }
}

template <class Writer>
void McAppendRequest::serialize(Writer&& writer) const {
  writer.writeStructBegin();
  writer.writeField(-1 /* field id */, memcacheRequestCommon_ref());
  writer.writeField(1 /* field id */, key_ref());
  writer.writeField(2 /* field id */, exptime_ref());
  writer.writeField(3 /* field id */, flags_ref());
  writer.writeField(4 /* field id */, value_ref());
  writer.writeFieldStop();
  writer.writeStructEnd();
}

template <class V>
void McAppendRequest::visitFields(V&& v) {
  if (v.enterMixin(1, "MemcacheRequestCommon", memcacheRequestCommon)) {
    this->memcacheRequestCommon.visitFields(std::forward<V>(v));
  }
  if (!v.leaveMixin()) {
    return;
  }
  if (!v.visitField(1, "key", *this->key_ref())) {
    return;
  }
  if (!v.visitField(2, "exptime", *this->exptime_ref())) {
    return;
  }
  if (!v.visitField(3, "flags", *this->flags_ref())) {
    return;
  }
  if (!v.visitField(4, "value", *this->value_ref())) {
    return;
  }
}

template <class V>
void McAppendRequest::visitFields(V&& v) const {
  if (v.enterMixin(1, "MemcacheRequestCommon", memcacheRequestCommon)) {
    this->memcacheRequestCommon.visitFields(std::forward<V>(v));
  }
  if (!v.leaveMixin()) {
    return;
  }
  if (!v.visitField(1, "key", *this->key_ref())) {
    return;
  }
  if (!v.visitField(2, "exptime", *this->exptime_ref())) {
    return;
  }
  if (!v.visitField(3, "flags", *this->flags_ref())) {
    return;
  }
  if (!v.visitField(4, "value", *this->value_ref())) {
    return;
  }
}

template <class Writer>
void McAppendReply::serialize(Writer&& writer) const {
  writer.writeStructBegin();
  writer.writeField(-1 /* field id */, memcacheReplyCommon_ref());
  writer.writeField(1 /* field id */, result_ref());
  writer.writeField(2 /* field id */, message_ref());
  writer.writeField(3 /* field id */, appSpecificErrorCode_ref());
  writer.writeFieldStop();
  writer.writeStructEnd();
}

template <class V>
void McAppendReply::visitFields(V&& v) {
  if (v.enterMixin(1, "MemcacheReplyCommon", memcacheReplyCommon)) {
    this->memcacheReplyCommon.visitFields(std::forward<V>(v));
  }
  if (!v.leaveMixin()) {
    return;
  }
  if (!v.visitField(1, "result", *this->result_ref())) {
    return;
  }
  if (!v.visitField(2, "message", *this->message_ref())) {
    return;
  }
  if (!v.visitField(3, "appSpecificErrorCode", *this->appSpecificErrorCode_ref())) {
    return;
  }
}

template <class V>
void McAppendReply::visitFields(V&& v) const {
  if (v.enterMixin(1, "MemcacheReplyCommon", memcacheReplyCommon)) {
    this->memcacheReplyCommon.visitFields(std::forward<V>(v));
  }
  if (!v.leaveMixin()) {
    return;
  }
  if (!v.visitField(1, "result", *this->result_ref())) {
    return;
  }
  if (!v.visitField(2, "message", *this->message_ref())) {
    return;
  }
  if (!v.visitField(3, "appSpecificErrorCode", *this->appSpecificErrorCode_ref())) {
    return;
  }
}

template <class Writer>
void McPrependRequest::serialize(Writer&& writer) const {
  writer.writeStructBegin();
  writer.writeField(-1 /* field id */, memcacheRequestCommon_ref());
  writer.writeField(1 /* field id */, key_ref());
  writer.writeField(2 /* field id */, exptime_ref());
  writer.writeField(3 /* field id */, flags_ref());
  writer.writeField(4 /* field id */, value_ref());
  writer.writeFieldStop();
  writer.writeStructEnd();
}

template <class V>
void McPrependRequest::visitFields(V&& v) {
  if (v.enterMixin(1, "MemcacheRequestCommon", memcacheRequestCommon)) {
    this->memcacheRequestCommon.visitFields(std::forward<V>(v));
  }
  if (!v.leaveMixin()) {
    return;
  }
  if (!v.visitField(1, "key", *this->key_ref())) {
    return;
  }
  if (!v.visitField(2, "exptime", *this->exptime_ref())) {
    return;
  }
  if (!v.visitField(3, "flags", *this->flags_ref())) {
    return;
  }
  if (!v.visitField(4, "value", *this->value_ref())) {
    return;
  }
}

template <class V>
void McPrependRequest::visitFields(V&& v) const {
  if (v.enterMixin(1, "MemcacheRequestCommon", memcacheRequestCommon)) {
    this->memcacheRequestCommon.visitFields(std::forward<V>(v));
  }
  if (!v.leaveMixin()) {
    return;
  }
  if (!v.visitField(1, "key", *this->key_ref())) {
    return;
  }
  if (!v.visitField(2, "exptime", *this->exptime_ref())) {
    return;
  }
  if (!v.visitField(3, "flags", *this->flags_ref())) {
    return;
  }
  if (!v.visitField(4, "value", *this->value_ref())) {
    return;
  }
}

template <class Writer>
void McPrependReply::serialize(Writer&& writer) const {
  writer.writeStructBegin();
  writer.writeField(-1 /* field id */, memcacheReplyCommon_ref());
  writer.writeField(1 /* field id */, result_ref());
  writer.writeField(2 /* field id */, message_ref());
  writer.writeField(3 /* field id */, appSpecificErrorCode_ref());
  writer.writeFieldStop();
  writer.writeStructEnd();
}

template <class V>
void McPrependReply::visitFields(V&& v) {
  if (v.enterMixin(1, "MemcacheReplyCommon", memcacheReplyCommon)) {
    this->memcacheReplyCommon.visitFields(std::forward<V>(v));
  }
  if (!v.leaveMixin()) {
    return;
  }
  if (!v.visitField(1, "result", *this->result_ref())) {
    return;
  }
  if (!v.visitField(2, "message", *this->message_ref())) {
    return;
  }
  if (!v.visitField(3, "appSpecificErrorCode", *this->appSpecificErrorCode_ref())) {
    return;
  }
}

template <class V>
void McPrependReply::visitFields(V&& v) const {
  if (v.enterMixin(1, "MemcacheReplyCommon", memcacheReplyCommon)) {
    this->memcacheReplyCommon.visitFields(std::forward<V>(v));
  }
  if (!v.leaveMixin()) {
    return;
  }
  if (!v.visitField(1, "result", *this->result_ref())) {
    return;
  }
  if (!v.visitField(2, "message", *this->message_ref())) {
    return;
  }
  if (!v.visitField(3, "appSpecificErrorCode", *this->appSpecificErrorCode_ref())) {
    return;
  }
}

template <class Writer>
void McTouchRequest::serialize(Writer&& writer) const {
  writer.writeStructBegin();
  writer.writeField(-1 /* field id */, memcacheRequestCommon_ref());
  writer.writeField(1 /* field id */, key_ref());
  writer.writeField(2 /* field id */, exptime_ref());
  writer.writeFieldStop();
  writer.writeStructEnd();
}

template <class V>
void McTouchRequest::visitFields(V&& v) {
  if (v.enterMixin(1, "MemcacheRequestCommon", memcacheRequestCommon)) {
    this->memcacheRequestCommon.visitFields(std::forward<V>(v));
  }
  if (!v.leaveMixin()) {
    return;
  }
  if (!v.visitField(1, "key", *this->key_ref())) {
    return;
  }
  if (!v.visitField(2, "exptime", *this->exptime_ref())) {
    return;
  }
}

template <class V>
void McTouchRequest::visitFields(V&& v) const {
  if (v.enterMixin(1, "MemcacheRequestCommon", memcacheRequestCommon)) {
    this->memcacheRequestCommon.visitFields(std::forward<V>(v));
  }
  if (!v.leaveMixin()) {
    return;
  }
  if (!v.visitField(1, "key", *this->key_ref())) {
    return;
  }
  if (!v.visitField(2, "exptime", *this->exptime_ref())) {
    return;
  }
}

template <class Writer>
void McTouchReply::serialize(Writer&& writer) const {
  writer.writeStructBegin();
  writer.writeField(-1 /* field id */, memcacheReplyCommon_ref());
  writer.writeField(1 /* field id */, result_ref());
  writer.writeField(2 /* field id */, message_ref());
  writer.writeField(3 /* field id */, appSpecificErrorCode_ref());
  writer.writeFieldStop();
  writer.writeStructEnd();
}

template <class V>
void McTouchReply::visitFields(V&& v) {
  if (v.enterMixin(1, "MemcacheReplyCommon", memcacheReplyCommon)) {
    this->memcacheReplyCommon.visitFields(std::forward<V>(v));
  }
  if (!v.leaveMixin()) {
    return;
  }
  if (!v.visitField(1, "result", *this->result_ref())) {
    return;
  }
  if (!v.visitField(2, "message", *this->message_ref())) {
    return;
  }
  if (!v.visitField(3, "appSpecificErrorCode", *this->appSpecificErrorCode_ref())) {
    return;
  }
}

template <class V>
void McTouchReply::visitFields(V&& v) const {
  if (v.enterMixin(1, "MemcacheReplyCommon", memcacheReplyCommon)) {
    this->memcacheReplyCommon.visitFields(std::forward<V>(v));
  }
  if (!v.leaveMixin()) {
    return;
  }
  if (!v.visitField(1, "result", *this->result_ref())) {
    return;
  }
  if (!v.visitField(2, "message", *this->message_ref())) {
    return;
  }
  if (!v.visitField(3, "appSpecificErrorCode", *this->appSpecificErrorCode_ref())) {
    return;
  }
}

template <class Writer>
void McFlushReRequest::serialize(Writer&& writer) const {
  writer.writeStructBegin();
  writer.writeField(-1 /* field id */, memcacheRequestCommon_ref());
  writer.writeField(1 /* field id */, key_ref());
  writer.writeFieldStop();
  writer.writeStructEnd();
}

template <class V>
void McFlushReRequest::visitFields(V&& v) {
  if (v.enterMixin(1, "MemcacheRequestCommon", memcacheRequestCommon)) {
    this->memcacheRequestCommon.visitFields(std::forward<V>(v));
  }
  if (!v.leaveMixin()) {
    return;
  }
  if (!v.visitField(1, "key", *this->key_ref())) {
    return;
  }
}

template <class V>
void McFlushReRequest::visitFields(V&& v) const {
  if (v.enterMixin(1, "MemcacheRequestCommon", memcacheRequestCommon)) {
    this->memcacheRequestCommon.visitFields(std::forward<V>(v));
  }
  if (!v.leaveMixin()) {
    return;
  }
  if (!v.visitField(1, "key", *this->key_ref())) {
    return;
  }
}

template <class Writer>
void McFlushReReply::serialize(Writer&& writer) const {
  writer.writeStructBegin();
  writer.writeField(-1 /* field id */, memcacheReplyCommon_ref());
  writer.writeField(1 /* field id */, result_ref());
  writer.writeField(2 /* field id */, message_ref());
  writer.writeField(3 /* field id */, appSpecificErrorCode_ref());
  writer.writeFieldStop();
  writer.writeStructEnd();
}

template <class V>
void McFlushReReply::visitFields(V&& v) {
  if (v.enterMixin(1, "MemcacheReplyCommon", memcacheReplyCommon)) {
    this->memcacheReplyCommon.visitFields(std::forward<V>(v));
  }
  if (!v.leaveMixin()) {
    return;
  }
  if (!v.visitField(1, "result", *this->result_ref())) {
    return;
  }
  if (!v.visitField(2, "message", *this->message_ref())) {
    return;
  }
  if (!v.visitField(3, "appSpecificErrorCode", *this->appSpecificErrorCode_ref())) {
    return;
  }
}

template <class V>
void McFlushReReply::visitFields(V&& v) const {
  if (v.enterMixin(1, "MemcacheReplyCommon", memcacheReplyCommon)) {
    this->memcacheReplyCommon.visitFields(std::forward<V>(v));
  }
  if (!v.leaveMixin()) {
    return;
  }
  if (!v.visitField(1, "result", *this->result_ref())) {
    return;
  }
  if (!v.visitField(2, "message", *this->message_ref())) {
    return;
  }
  if (!v.visitField(3, "appSpecificErrorCode", *this->appSpecificErrorCode_ref())) {
    return;
  }
}

template <class Writer>
void McFlushAllRequest::serialize(Writer&& writer) const {
  writer.writeStructBegin();
  writer.writeField(-1 /* field id */, memcacheRequestCommon_ref());
  writer.writeField(1 /* field id */, key_ref());
  writer.writeField(2 /* field id */, delay_ref());
  writer.writeFieldStop();
  writer.writeStructEnd();
}

template <class V>
void McFlushAllRequest::visitFields(V&& v) {
  if (v.enterMixin(1, "MemcacheRequestCommon", memcacheRequestCommon)) {
    this->memcacheRequestCommon.visitFields(std::forward<V>(v));
  }
  if (!v.leaveMixin()) {
    return;
  }
  if (!v.visitField(1, "key", *this->key_ref())) {
    return;
  }
  if (!v.visitField(2, "delay", *this->delay_ref())) {
    return;
  }
}

template <class V>
void McFlushAllRequest::visitFields(V&& v) const {
  if (v.enterMixin(1, "MemcacheRequestCommon", memcacheRequestCommon)) {
    this->memcacheRequestCommon.visitFields(std::forward<V>(v));
  }
  if (!v.leaveMixin()) {
    return;
  }
  if (!v.visitField(1, "key", *this->key_ref())) {
    return;
  }
  if (!v.visitField(2, "delay", *this->delay_ref())) {
    return;
  }
}

template <class Writer>
void McFlushAllReply::serialize(Writer&& writer) const {
  writer.writeStructBegin();
  writer.writeField(-1 /* field id */, memcacheReplyCommon_ref());
  writer.writeField(1 /* field id */, result_ref());
  writer.writeField(2 /* field id */, message_ref());
  writer.writeField(3 /* field id */, appSpecificErrorCode_ref());
  writer.writeFieldStop();
  writer.writeStructEnd();
}

template <class V>
void McFlushAllReply::visitFields(V&& v) {
  if (v.enterMixin(1, "MemcacheReplyCommon", memcacheReplyCommon)) {
    this->memcacheReplyCommon.visitFields(std::forward<V>(v));
  }
  if (!v.leaveMixin()) {
    return;
  }
  if (!v.visitField(1, "result", *this->result_ref())) {
    return;
  }
  if (!v.visitField(2, "message", *this->message_ref())) {
    return;
  }
  if (!v.visitField(3, "appSpecificErrorCode", *this->appSpecificErrorCode_ref())) {
    return;
  }
}

template <class V>
void McFlushAllReply::visitFields(V&& v) const {
  if (v.enterMixin(1, "MemcacheReplyCommon", memcacheReplyCommon)) {
    this->memcacheReplyCommon.visitFields(std::forward<V>(v));
  }
  if (!v.leaveMixin()) {
    return;
  }
  if (!v.visitField(1, "result", *this->result_ref())) {
    return;
  }
  if (!v.visitField(2, "message", *this->message_ref())) {
    return;
  }
  if (!v.visitField(3, "appSpecificErrorCode", *this->appSpecificErrorCode_ref())) {
    return;
  }
}

template <class Writer>
void McGatRequest::serialize(Writer&& writer) const {
  writer.writeStructBegin();
  writer.writeField(-1 /* field id */, memcacheRequestCommon_ref());
  writer.writeField(1 /* field id */, exptime_ref());
  writer.writeField(2 /* field id */, key_ref());
  writer.writeFieldStop();
  writer.writeStructEnd();
}

template <class V>
void McGatRequest::visitFields(V&& v) {
  if (v.enterMixin(1, "MemcacheRequestCommon", memcacheRequestCommon)) {
    this->memcacheRequestCommon.visitFields(std::forward<V>(v));
  }
  if (!v.leaveMixin()) {
    return;
  }
  if (!v.visitField(1, "exptime", *this->exptime_ref())) {
    return;
  }
  if (!v.visitField(2, "key", *this->key_ref())) {
    return;
  }
}

template <class V>
void McGatRequest::visitFields(V&& v) const {
  if (v.enterMixin(1, "MemcacheRequestCommon", memcacheRequestCommon)) {
    this->memcacheRequestCommon.visitFields(std::forward<V>(v));
  }
  if (!v.leaveMixin()) {
    return;
  }
  if (!v.visitField(1, "exptime", *this->exptime_ref())) {
    return;
  }
  if (!v.visitField(2, "key", *this->key_ref())) {
    return;
  }
}

template <class Writer>
void McGatReply::serialize(Writer&& writer) const {
  writer.writeStructBegin();
  writer.writeField(-1 /* field id */, memcacheReplyCommon_ref());
  writer.writeField(1 /* field id */, result_ref());
  writer.writeField(2 /* field id */, value_ref());
  writer.writeField(3 /* field id */, flags_ref());
  writer.writeField(4 /* field id */, message_ref());
  writer.writeField(5 /* field id */, appSpecificErrorCode_ref());
  writer.writeFieldStop();
  writer.writeStructEnd();
}

template <class V>
void McGatReply::visitFields(V&& v) {
  if (v.enterMixin(1, "MemcacheReplyCommon", memcacheReplyCommon)) {
    this->memcacheReplyCommon.visitFields(std::forward<V>(v));
  }
  if (!v.leaveMixin()) {
    return;
  }
  if (!v.visitField(1, "result", *this->result_ref())) {
    return;
  }
  if (!v.visitField(2, "value", this->value_ref())) {
    return;
  }
  if (!v.visitField(3, "flags", *this->flags_ref())) {
    return;
  }
  if (!v.visitField(4, "message", *this->message_ref())) {
    return;
  }
  if (!v.visitField(5, "appSpecificErrorCode", *this->appSpecificErrorCode_ref())) {
    return;
  }
}

template <class V>
void McGatReply::visitFields(V&& v) const {
  if (v.enterMixin(1, "MemcacheReplyCommon", memcacheReplyCommon)) {
    this->memcacheReplyCommon.visitFields(std::forward<V>(v));
  }
  if (!v.leaveMixin()) {
    return;
  }
  if (!v.visitField(1, "result", *this->result_ref())) {
    return;
  }
  if (!v.visitField(2, "value", this->value_ref())) {
    return;
  }
  if (!v.visitField(3, "flags", *this->flags_ref())) {
    return;
  }
  if (!v.visitField(4, "message", *this->message_ref())) {
    return;
  }
  if (!v.visitField(5, "appSpecificErrorCode", *this->appSpecificErrorCode_ref())) {
    return;
  }
}

template <class Writer>
void McGatsRequest::serialize(Writer&& writer) const {
  writer.writeStructBegin();
  writer.writeField(-1 /* field id */, memcacheRequestCommon_ref());
  writer.writeField(1 /* field id */, exptime_ref());
  writer.writeField(2 /* field id */, key_ref());
  writer.writeFieldStop();
  writer.writeStructEnd();
}

template <class V>
void McGatsRequest::visitFields(V&& v) {
  if (v.enterMixin(1, "MemcacheRequestCommon", memcacheRequestCommon)) {
    this->memcacheRequestCommon.visitFields(std::forward<V>(v));
  }
  if (!v.leaveMixin()) {
    return;
  }
  if (!v.visitField(1, "exptime", *this->exptime_ref())) {
    return;
  }
  if (!v.visitField(2, "key", *this->key_ref())) {
    return;
  }
}

template <class V>
void McGatsRequest::visitFields(V&& v) const {
  if (v.enterMixin(1, "MemcacheRequestCommon", memcacheRequestCommon)) {
    this->memcacheRequestCommon.visitFields(std::forward<V>(v));
  }
  if (!v.leaveMixin()) {
    return;
  }
  if (!v.visitField(1, "exptime", *this->exptime_ref())) {
    return;
  }
  if (!v.visitField(2, "key", *this->key_ref())) {
    return;
  }
}

template <class Writer>
void McGatsReply::serialize(Writer&& writer) const {
  writer.writeStructBegin();
  writer.writeField(-1 /* field id */, memcacheReplyCommon_ref());
  writer.writeField(1 /* field id */, result_ref());
  writer.writeField(2 /* field id */, casToken_ref());
  writer.writeField(3 /* field id */, value_ref());
  writer.writeField(4 /* field id */, flags_ref());
  writer.writeField(5 /* field id */, message_ref());
  writer.writeField(6 /* field id */, appSpecificErrorCode_ref());
  writer.writeFieldStop();
  writer.writeStructEnd();
}

template <class V>
void McGatsReply::visitFields(V&& v) {
  if (v.enterMixin(1, "MemcacheReplyCommon", memcacheReplyCommon)) {
    this->memcacheReplyCommon.visitFields(std::forward<V>(v));
  }
  if (!v.leaveMixin()) {
    return;
  }
  if (!v.visitField(1, "result", *this->result_ref())) {
    return;
  }
  if (!v.visitField(2, "casToken", *this->casToken_ref())) {
    return;
  }
  if (!v.visitField(3, "value", this->value_ref())) {
    return;
  }
  if (!v.visitField(4, "flags", *this->flags_ref())) {
    return;
  }
  if (!v.visitField(5, "message", *this->message_ref())) {
    return;
  }
  if (!v.visitField(6, "appSpecificErrorCode", *this->appSpecificErrorCode_ref())) {
    return;
  }
}

template <class V>
void McGatsReply::visitFields(V&& v) const {
  if (v.enterMixin(1, "MemcacheReplyCommon", memcacheReplyCommon)) {
    this->memcacheReplyCommon.visitFields(std::forward<V>(v));
  }
  if (!v.leaveMixin()) {
    return;
  }
  if (!v.visitField(1, "result", *this->result_ref())) {
    return;
  }
  if (!v.visitField(2, "casToken", *this->casToken_ref())) {
    return;
  }
  if (!v.visitField(3, "value", this->value_ref())) {
    return;
  }
  if (!v.visitField(4, "flags", *this->flags_ref())) {
    return;
  }
  if (!v.visitField(5, "message", *this->message_ref())) {
    return;
  }
  if (!v.visitField(6, "appSpecificErrorCode", *this->appSpecificErrorCode_ref())) {
    return;
  }
}
} // namespace thrift
} // namespace memcache
} // namespace facebook

namespace apache {
namespace thrift {
template <>
class Cpp2Ops<facebook::memcache::MemcacheRequestCommon> {
 public:
  typedef facebook::memcache::MemcacheRequestCommon Type;
  static constexpr protocol::TType thriftType() {
    return protocol::T_STRUCT;
  }
  template <class Protocol>
  static uint32_t write(Protocol* prot, const Type* value) {
    return value->write(prot);
  }
  template <class Protocol>
  static void read(Protocol* prot, Type* value) {
    value->read(prot);
  }
  template <class Protocol>
  static uint32_t serializedSize(Protocol* prot, const Type* value) {
    return value->serializedSize(prot);
  }
  template <class Protocol>
  static uint32_t serializedSizeZC(Protocol* prot, const Type* value) {
    return value->serializedSizeZC(prot);
  }
};

template <>
class Cpp2Ops<facebook::memcache::MemcacheReplyCommon> {
 public:
  typedef facebook::memcache::MemcacheReplyCommon Type;
  static constexpr protocol::TType thriftType() {
    return protocol::T_STRUCT;
  }
  template <class Protocol>
  static uint32_t write(Protocol* prot, const Type* value) {
    return value->write(prot);
  }
  template <class Protocol>
  static void read(Protocol* prot, Type* value) {
    value->read(prot);
  }
  template <class Protocol>
  static uint32_t serializedSize(Protocol* prot, const Type* value) {
    return value->serializedSize(prot);
  }
  template <class Protocol>
  static uint32_t serializedSizeZC(Protocol* prot, const Type* value) {
    return value->serializedSizeZC(prot);
  }
};

template <>
class Cpp2Ops<facebook::memcache::McGetRequest> {
 public:
  typedef facebook::memcache::McGetRequest Type;
  static constexpr protocol::TType thriftType() {
    return protocol::T_STRUCT;
  }
  template <class Protocol>
  static uint32_t write(Protocol* prot, const Type* value) {
    return value->write(prot);
  }
  template <class Protocol>
  static void read(Protocol* prot, Type* value) {
    value->read(prot);
  }
  template <class Protocol>
  static uint32_t serializedSize(Protocol* prot, const Type* value) {
    return value->serializedSize(prot);
  }
  template <class Protocol>
  static uint32_t serializedSizeZC(Protocol* prot, const Type* value) {
    return value->serializedSizeZC(prot);
  }
};

template <>
class Cpp2Ops<facebook::memcache::McGetReply> {
 public:
  typedef facebook::memcache::McGetReply Type;
  static constexpr protocol::TType thriftType() {
    return protocol::T_STRUCT;
  }
  template <class Protocol>
  static uint32_t write(Protocol* prot, const Type* value) {
    return value->write(prot);
  }
  template <class Protocol>
  static void read(Protocol* prot, Type* value) {
    value->read(prot);
  }
  template <class Protocol>
  static uint32_t serializedSize(Protocol* prot, const Type* value) {
    return value->serializedSize(prot);
  }
  template <class Protocol>
  static uint32_t serializedSizeZC(Protocol* prot, const Type* value) {
    return value->serializedSizeZC(prot);
  }
};

template <>
class Cpp2Ops<facebook::memcache::McSetRequest> {
 public:
  typedef facebook::memcache::McSetRequest Type;
  static constexpr protocol::TType thriftType() {
    return protocol::T_STRUCT;
  }
  template <class Protocol>
  static uint32_t write(Protocol* prot, const Type* value) {
    return value->write(prot);
  }
  template <class Protocol>
  static void read(Protocol* prot, Type* value) {
    value->read(prot);
  }
  template <class Protocol>
  static uint32_t serializedSize(Protocol* prot, const Type* value) {
    return value->serializedSize(prot);
  }
  template <class Protocol>
  static uint32_t serializedSizeZC(Protocol* prot, const Type* value) {
    return value->serializedSizeZC(prot);
  }
};

template <>
class Cpp2Ops<facebook::memcache::McSetReply> {
 public:
  typedef facebook::memcache::McSetReply Type;
  static constexpr protocol::TType thriftType() {
    return protocol::T_STRUCT;
  }
  template <class Protocol>
  static uint32_t write(Protocol* prot, const Type* value) {
    return value->write(prot);
  }
  template <class Protocol>
  static void read(Protocol* prot, Type* value) {
    value->read(prot);
  }
  template <class Protocol>
  static uint32_t serializedSize(Protocol* prot, const Type* value) {
    return value->serializedSize(prot);
  }
  template <class Protocol>
  static uint32_t serializedSizeZC(Protocol* prot, const Type* value) {
    return value->serializedSizeZC(prot);
  }
};

template <>
class Cpp2Ops<facebook::memcache::McDeleteRequest> {
 public:
  typedef facebook::memcache::McDeleteRequest Type;
  static constexpr protocol::TType thriftType() {
    return protocol::T_STRUCT;
  }
  template <class Protocol>
  static uint32_t write(Protocol* prot, const Type* value) {
    return value->write(prot);
  }
  template <class Protocol>
  static void read(Protocol* prot, Type* value) {
    value->read(prot);
  }
  template <class Protocol>
  static uint32_t serializedSize(Protocol* prot, const Type* value) {
    return value->serializedSize(prot);
  }
  template <class Protocol>
  static uint32_t serializedSizeZC(Protocol* prot, const Type* value) {
    return value->serializedSizeZC(prot);
  }
};

template <>
class Cpp2Ops<facebook::memcache::McDeleteReply> {
 public:
  typedef facebook::memcache::McDeleteReply Type;
  static constexpr protocol::TType thriftType() {
    return protocol::T_STRUCT;
  }
  template <class Protocol>
  static uint32_t write(Protocol* prot, const Type* value) {
    return value->write(prot);
  }
  template <class Protocol>
  static void read(Protocol* prot, Type* value) {
    value->read(prot);
  }
  template <class Protocol>
  static uint32_t serializedSize(Protocol* prot, const Type* value) {
    return value->serializedSize(prot);
  }
  template <class Protocol>
  static uint32_t serializedSizeZC(Protocol* prot, const Type* value) {
    return value->serializedSizeZC(prot);
  }
};

template <>
class Cpp2Ops<facebook::memcache::McLeaseGetRequest> {
 public:
  typedef facebook::memcache::McLeaseGetRequest Type;
  static constexpr protocol::TType thriftType() {
    return protocol::T_STRUCT;
  }
  template <class Protocol>
  static uint32_t write(Protocol* prot, const Type* value) {
    return value->write(prot);
  }
  template <class Protocol>
  static void read(Protocol* prot, Type* value) {
    value->read(prot);
  }
  template <class Protocol>
  static uint32_t serializedSize(Protocol* prot, const Type* value) {
    return value->serializedSize(prot);
  }
  template <class Protocol>
  static uint32_t serializedSizeZC(Protocol* prot, const Type* value) {
    return value->serializedSizeZC(prot);
  }
};

template <>
class Cpp2Ops<facebook::memcache::McLeaseGetReply> {
 public:
  typedef facebook::memcache::McLeaseGetReply Type;
  static constexpr protocol::TType thriftType() {
    return protocol::T_STRUCT;
  }
  template <class Protocol>
  static uint32_t write(Protocol* prot, const Type* value) {
    return value->write(prot);
  }
  template <class Protocol>
  static void read(Protocol* prot, Type* value) {
    value->read(prot);
  }
  template <class Protocol>
  static uint32_t serializedSize(Protocol* prot, const Type* value) {
    return value->serializedSize(prot);
  }
  template <class Protocol>
  static uint32_t serializedSizeZC(Protocol* prot, const Type* value) {
    return value->serializedSizeZC(prot);
  }
};

template <>
class Cpp2Ops<facebook::memcache::McLeaseSetRequest> {
 public:
  typedef facebook::memcache::McLeaseSetRequest Type;
  static constexpr protocol::TType thriftType() {
    return protocol::T_STRUCT;
  }
  template <class Protocol>
  static uint32_t write(Protocol* prot, const Type* value) {
    return value->write(prot);
  }
  template <class Protocol>
  static void read(Protocol* prot, Type* value) {
    value->read(prot);
  }
  template <class Protocol>
  static uint32_t serializedSize(Protocol* prot, const Type* value) {
    return value->serializedSize(prot);
  }
  template <class Protocol>
  static uint32_t serializedSizeZC(Protocol* prot, const Type* value) {
    return value->serializedSizeZC(prot);
  }
};

template <>
class Cpp2Ops<facebook::memcache::McLeaseSetReply> {
 public:
  typedef facebook::memcache::McLeaseSetReply Type;
  static constexpr protocol::TType thriftType() {
    return protocol::T_STRUCT;
  }
  template <class Protocol>
  static uint32_t write(Protocol* prot, const Type* value) {
    return value->write(prot);
  }
  template <class Protocol>
  static void read(Protocol* prot, Type* value) {
    value->read(prot);
  }
  template <class Protocol>
  static uint32_t serializedSize(Protocol* prot, const Type* value) {
    return value->serializedSize(prot);
  }
  template <class Protocol>
  static uint32_t serializedSizeZC(Protocol* prot, const Type* value) {
    return value->serializedSizeZC(prot);
  }
};

template <>
class Cpp2Ops<facebook::memcache::McAddRequest> {
 public:
  typedef facebook::memcache::McAddRequest Type;
  static constexpr protocol::TType thriftType() {
    return protocol::T_STRUCT;
  }
  template <class Protocol>
  static uint32_t write(Protocol* prot, const Type* value) {
    return value->write(prot);
  }
  template <class Protocol>
  static void read(Protocol* prot, Type* value) {
    value->read(prot);
  }
  template <class Protocol>
  static uint32_t serializedSize(Protocol* prot, const Type* value) {
    return value->serializedSize(prot);
  }
  template <class Protocol>
  static uint32_t serializedSizeZC(Protocol* prot, const Type* value) {
    return value->serializedSizeZC(prot);
  }
};

template <>
class Cpp2Ops<facebook::memcache::McAddReply> {
 public:
  typedef facebook::memcache::McAddReply Type;
  static constexpr protocol::TType thriftType() {
    return protocol::T_STRUCT;
  }
  template <class Protocol>
  static uint32_t write(Protocol* prot, const Type* value) {
    return value->write(prot);
  }
  template <class Protocol>
  static void read(Protocol* prot, Type* value) {
    value->read(prot);
  }
  template <class Protocol>
  static uint32_t serializedSize(Protocol* prot, const Type* value) {
    return value->serializedSize(prot);
  }
  template <class Protocol>
  static uint32_t serializedSizeZC(Protocol* prot, const Type* value) {
    return value->serializedSizeZC(prot);
  }
};

template <>
class Cpp2Ops<facebook::memcache::McReplaceRequest> {
 public:
  typedef facebook::memcache::McReplaceRequest Type;
  static constexpr protocol::TType thriftType() {
    return protocol::T_STRUCT;
  }
  template <class Protocol>
  static uint32_t write(Protocol* prot, const Type* value) {
    return value->write(prot);
  }
  template <class Protocol>
  static void read(Protocol* prot, Type* value) {
    value->read(prot);
  }
  template <class Protocol>
  static uint32_t serializedSize(Protocol* prot, const Type* value) {
    return value->serializedSize(prot);
  }
  template <class Protocol>
  static uint32_t serializedSizeZC(Protocol* prot, const Type* value) {
    return value->serializedSizeZC(prot);
  }
};

template <>
class Cpp2Ops<facebook::memcache::McReplaceReply> {
 public:
  typedef facebook::memcache::McReplaceReply Type;
  static constexpr protocol::TType thriftType() {
    return protocol::T_STRUCT;
  }
  template <class Protocol>
  static uint32_t write(Protocol* prot, const Type* value) {
    return value->write(prot);
  }
  template <class Protocol>
  static void read(Protocol* prot, Type* value) {
    value->read(prot);
  }
  template <class Protocol>
  static uint32_t serializedSize(Protocol* prot, const Type* value) {
    return value->serializedSize(prot);
  }
  template <class Protocol>
  static uint32_t serializedSizeZC(Protocol* prot, const Type* value) {
    return value->serializedSizeZC(prot);
  }
};

template <>
class Cpp2Ops<facebook::memcache::McGetsRequest> {
 public:
  typedef facebook::memcache::McGetsRequest Type;
  static constexpr protocol::TType thriftType() {
    return protocol::T_STRUCT;
  }
  template <class Protocol>
  static uint32_t write(Protocol* prot, const Type* value) {
    return value->write(prot);
  }
  template <class Protocol>
  static void read(Protocol* prot, Type* value) {
    value->read(prot);
  }
  template <class Protocol>
  static uint32_t serializedSize(Protocol* prot, const Type* value) {
    return value->serializedSize(prot);
  }
  template <class Protocol>
  static uint32_t serializedSizeZC(Protocol* prot, const Type* value) {
    return value->serializedSizeZC(prot);
  }
};

template <>
class Cpp2Ops<facebook::memcache::McGetsReply> {
 public:
  typedef facebook::memcache::McGetsReply Type;
  static constexpr protocol::TType thriftType() {
    return protocol::T_STRUCT;
  }
  template <class Protocol>
  static uint32_t write(Protocol* prot, const Type* value) {
    return value->write(prot);
  }
  template <class Protocol>
  static void read(Protocol* prot, Type* value) {
    value->read(prot);
  }
  template <class Protocol>
  static uint32_t serializedSize(Protocol* prot, const Type* value) {
    return value->serializedSize(prot);
  }
  template <class Protocol>
  static uint32_t serializedSizeZC(Protocol* prot, const Type* value) {
    return value->serializedSizeZC(prot);
  }
};

template <>
class Cpp2Ops<facebook::memcache::McCasRequest> {
 public:
  typedef facebook::memcache::McCasRequest Type;
  static constexpr protocol::TType thriftType() {
    return protocol::T_STRUCT;
  }
  template <class Protocol>
  static uint32_t write(Protocol* prot, const Type* value) {
    return value->write(prot);
  }
  template <class Protocol>
  static void read(Protocol* prot, Type* value) {
    value->read(prot);
  }
  template <class Protocol>
  static uint32_t serializedSize(Protocol* prot, const Type* value) {
    return value->serializedSize(prot);
  }
  template <class Protocol>
  static uint32_t serializedSizeZC(Protocol* prot, const Type* value) {
    return value->serializedSizeZC(prot);
  }
};

template <>
class Cpp2Ops<facebook::memcache::McCasReply> {
 public:
  typedef facebook::memcache::McCasReply Type;
  static constexpr protocol::TType thriftType() {
    return protocol::T_STRUCT;
  }
  template <class Protocol>
  static uint32_t write(Protocol* prot, const Type* value) {
    return value->write(prot);
  }
  template <class Protocol>
  static void read(Protocol* prot, Type* value) {
    value->read(prot);
  }
  template <class Protocol>
  static uint32_t serializedSize(Protocol* prot, const Type* value) {
    return value->serializedSize(prot);
  }
  template <class Protocol>
  static uint32_t serializedSizeZC(Protocol* prot, const Type* value) {
    return value->serializedSizeZC(prot);
  }
};

template <>
class Cpp2Ops<facebook::memcache::McIncrRequest> {
 public:
  typedef facebook::memcache::McIncrRequest Type;
  static constexpr protocol::TType thriftType() {
    return protocol::T_STRUCT;
  }
  template <class Protocol>
  static uint32_t write(Protocol* prot, const Type* value) {
    return value->write(prot);
  }
  template <class Protocol>
  static void read(Protocol* prot, Type* value) {
    value->read(prot);
  }
  template <class Protocol>
  static uint32_t serializedSize(Protocol* prot, const Type* value) {
    return value->serializedSize(prot);
  }
  template <class Protocol>
  static uint32_t serializedSizeZC(Protocol* prot, const Type* value) {
    return value->serializedSizeZC(prot);
  }
};

template <>
class Cpp2Ops<facebook::memcache::McIncrReply> {
 public:
  typedef facebook::memcache::McIncrReply Type;
  static constexpr protocol::TType thriftType() {
    return protocol::T_STRUCT;
  }
  template <class Protocol>
  static uint32_t write(Protocol* prot, const Type* value) {
    return value->write(prot);
  }
  template <class Protocol>
  static void read(Protocol* prot, Type* value) {
    value->read(prot);
  }
  template <class Protocol>
  static uint32_t serializedSize(Protocol* prot, const Type* value) {
    return value->serializedSize(prot);
  }
  template <class Protocol>
  static uint32_t serializedSizeZC(Protocol* prot, const Type* value) {
    return value->serializedSizeZC(prot);
  }
};

template <>
class Cpp2Ops<facebook::memcache::McDecrRequest> {
 public:
  typedef facebook::memcache::McDecrRequest Type;
  static constexpr protocol::TType thriftType() {
    return protocol::T_STRUCT;
  }
  template <class Protocol>
  static uint32_t write(Protocol* prot, const Type* value) {
    return value->write(prot);
  }
  template <class Protocol>
  static void read(Protocol* prot, Type* value) {
    value->read(prot);
  }
  template <class Protocol>
  static uint32_t serializedSize(Protocol* prot, const Type* value) {
    return value->serializedSize(prot);
  }
  template <class Protocol>
  static uint32_t serializedSizeZC(Protocol* prot, const Type* value) {
    return value->serializedSizeZC(prot);
  }
};

template <>
class Cpp2Ops<facebook::memcache::McDecrReply> {
 public:
  typedef facebook::memcache::McDecrReply Type;
  static constexpr protocol::TType thriftType() {
    return protocol::T_STRUCT;
  }
  template <class Protocol>
  static uint32_t write(Protocol* prot, const Type* value) {
    return value->write(prot);
  }
  template <class Protocol>
  static void read(Protocol* prot, Type* value) {
    value->read(prot);
  }
  template <class Protocol>
  static uint32_t serializedSize(Protocol* prot, const Type* value) {
    return value->serializedSize(prot);
  }
  template <class Protocol>
  static uint32_t serializedSizeZC(Protocol* prot, const Type* value) {
    return value->serializedSizeZC(prot);
  }
};

template <>
class Cpp2Ops<facebook::memcache::McMetagetRequest> {
 public:
  typedef facebook::memcache::McMetagetRequest Type;
  static constexpr protocol::TType thriftType() {
    return protocol::T_STRUCT;
  }
  template <class Protocol>
  static uint32_t write(Protocol* prot, const Type* value) {
    return value->write(prot);
  }
  template <class Protocol>
  static void read(Protocol* prot, Type* value) {
    value->read(prot);
  }
  template <class Protocol>
  static uint32_t serializedSize(Protocol* prot, const Type* value) {
    return value->serializedSize(prot);
  }
  template <class Protocol>
  static uint32_t serializedSizeZC(Protocol* prot, const Type* value) {
    return value->serializedSizeZC(prot);
  }
};

template <>
class Cpp2Ops<facebook::memcache::McMetagetReply> {
 public:
  typedef facebook::memcache::McMetagetReply Type;
  static constexpr protocol::TType thriftType() {
    return protocol::T_STRUCT;
  }
  template <class Protocol>
  static uint32_t write(Protocol* prot, const Type* value) {
    return value->write(prot);
  }
  template <class Protocol>
  static void read(Protocol* prot, Type* value) {
    value->read(prot);
  }
  template <class Protocol>
  static uint32_t serializedSize(Protocol* prot, const Type* value) {
    return value->serializedSize(prot);
  }
  template <class Protocol>
  static uint32_t serializedSizeZC(Protocol* prot, const Type* value) {
    return value->serializedSizeZC(prot);
  }
};

template <>
class Cpp2Ops<facebook::memcache::McAppendRequest> {
 public:
  typedef facebook::memcache::McAppendRequest Type;
  static constexpr protocol::TType thriftType() {
    return protocol::T_STRUCT;
  }
  template <class Protocol>
  static uint32_t write(Protocol* prot, const Type* value) {
    return value->write(prot);
  }
  template <class Protocol>
  static void read(Protocol* prot, Type* value) {
    value->read(prot);
  }
  template <class Protocol>
  static uint32_t serializedSize(Protocol* prot, const Type* value) {
    return value->serializedSize(prot);
  }
  template <class Protocol>
  static uint32_t serializedSizeZC(Protocol* prot, const Type* value) {
    return value->serializedSizeZC(prot);
  }
};

template <>
class Cpp2Ops<facebook::memcache::McAppendReply> {
 public:
  typedef facebook::memcache::McAppendReply Type;
  static constexpr protocol::TType thriftType() {
    return protocol::T_STRUCT;
  }
  template <class Protocol>
  static uint32_t write(Protocol* prot, const Type* value) {
    return value->write(prot);
  }
  template <class Protocol>
  static void read(Protocol* prot, Type* value) {
    value->read(prot);
  }
  template <class Protocol>
  static uint32_t serializedSize(Protocol* prot, const Type* value) {
    return value->serializedSize(prot);
  }
  template <class Protocol>
  static uint32_t serializedSizeZC(Protocol* prot, const Type* value) {
    return value->serializedSizeZC(prot);
  }
};

template <>
class Cpp2Ops<facebook::memcache::McPrependRequest> {
 public:
  typedef facebook::memcache::McPrependRequest Type;
  static constexpr protocol::TType thriftType() {
    return protocol::T_STRUCT;
  }
  template <class Protocol>
  static uint32_t write(Protocol* prot, const Type* value) {
    return value->write(prot);
  }
  template <class Protocol>
  static void read(Protocol* prot, Type* value) {
    value->read(prot);
  }
  template <class Protocol>
  static uint32_t serializedSize(Protocol* prot, const Type* value) {
    return value->serializedSize(prot);
  }
  template <class Protocol>
  static uint32_t serializedSizeZC(Protocol* prot, const Type* value) {
    return value->serializedSizeZC(prot);
  }
};

template <>
class Cpp2Ops<facebook::memcache::McPrependReply> {
 public:
  typedef facebook::memcache::McPrependReply Type;
  static constexpr protocol::TType thriftType() {
    return protocol::T_STRUCT;
  }
  template <class Protocol>
  static uint32_t write(Protocol* prot, const Type* value) {
    return value->write(prot);
  }
  template <class Protocol>
  static void read(Protocol* prot, Type* value) {
    value->read(prot);
  }
  template <class Protocol>
  static uint32_t serializedSize(Protocol* prot, const Type* value) {
    return value->serializedSize(prot);
  }
  template <class Protocol>
  static uint32_t serializedSizeZC(Protocol* prot, const Type* value) {
    return value->serializedSizeZC(prot);
  }
};

template <>
class Cpp2Ops<facebook::memcache::McTouchRequest> {
 public:
  typedef facebook::memcache::McTouchRequest Type;
  static constexpr protocol::TType thriftType() {
    return protocol::T_STRUCT;
  }
  template <class Protocol>
  static uint32_t write(Protocol* prot, const Type* value) {
    return value->write(prot);
  }
  template <class Protocol>
  static void read(Protocol* prot, Type* value) {
    value->read(prot);
  }
  template <class Protocol>
  static uint32_t serializedSize(Protocol* prot, const Type* value) {
    return value->serializedSize(prot);
  }
  template <class Protocol>
  static uint32_t serializedSizeZC(Protocol* prot, const Type* value) {
    return value->serializedSizeZC(prot);
  }
};

template <>
class Cpp2Ops<facebook::memcache::McTouchReply> {
 public:
  typedef facebook::memcache::McTouchReply Type;
  static constexpr protocol::TType thriftType() {
    return protocol::T_STRUCT;
  }
  template <class Protocol>
  static uint32_t write(Protocol* prot, const Type* value) {
    return value->write(prot);
  }
  template <class Protocol>
  static void read(Protocol* prot, Type* value) {
    value->read(prot);
  }
  template <class Protocol>
  static uint32_t serializedSize(Protocol* prot, const Type* value) {
    return value->serializedSize(prot);
  }
  template <class Protocol>
  static uint32_t serializedSizeZC(Protocol* prot, const Type* value) {
    return value->serializedSizeZC(prot);
  }
};

template <>
class Cpp2Ops<facebook::memcache::McFlushReRequest> {
 public:
  typedef facebook::memcache::McFlushReRequest Type;
  static constexpr protocol::TType thriftType() {
    return protocol::T_STRUCT;
  }
  template <class Protocol>
  static uint32_t write(Protocol* prot, const Type* value) {
    return value->write(prot);
  }
  template <class Protocol>
  static void read(Protocol* prot, Type* value) {
    value->read(prot);
  }
  template <class Protocol>
  static uint32_t serializedSize(Protocol* prot, const Type* value) {
    return value->serializedSize(prot);
  }
  template <class Protocol>
  static uint32_t serializedSizeZC(Protocol* prot, const Type* value) {
    return value->serializedSizeZC(prot);
  }
};

template <>
class Cpp2Ops<facebook::memcache::McFlushReReply> {
 public:
  typedef facebook::memcache::McFlushReReply Type;
  static constexpr protocol::TType thriftType() {
    return protocol::T_STRUCT;
  }
  template <class Protocol>
  static uint32_t write(Protocol* prot, const Type* value) {
    return value->write(prot);
  }
  template <class Protocol>
  static void read(Protocol* prot, Type* value) {
    value->read(prot);
  }
  template <class Protocol>
  static uint32_t serializedSize(Protocol* prot, const Type* value) {
    return value->serializedSize(prot);
  }
  template <class Protocol>
  static uint32_t serializedSizeZC(Protocol* prot, const Type* value) {
    return value->serializedSizeZC(prot);
  }
};

template <>
class Cpp2Ops<facebook::memcache::McFlushAllRequest> {
 public:
  typedef facebook::memcache::McFlushAllRequest Type;
  static constexpr protocol::TType thriftType() {
    return protocol::T_STRUCT;
  }
  template <class Protocol>
  static uint32_t write(Protocol* prot, const Type* value) {
    return value->write(prot);
  }
  template <class Protocol>
  static void read(Protocol* prot, Type* value) {
    value->read(prot);
  }
  template <class Protocol>
  static uint32_t serializedSize(Protocol* prot, const Type* value) {
    return value->serializedSize(prot);
  }
  template <class Protocol>
  static uint32_t serializedSizeZC(Protocol* prot, const Type* value) {
    return value->serializedSizeZC(prot);
  }
};

template <>
class Cpp2Ops<facebook::memcache::McFlushAllReply> {
 public:
  typedef facebook::memcache::McFlushAllReply Type;
  static constexpr protocol::TType thriftType() {
    return protocol::T_STRUCT;
  }
  template <class Protocol>
  static uint32_t write(Protocol* prot, const Type* value) {
    return value->write(prot);
  }
  template <class Protocol>
  static void read(Protocol* prot, Type* value) {
    value->read(prot);
  }
  template <class Protocol>
  static uint32_t serializedSize(Protocol* prot, const Type* value) {
    return value->serializedSize(prot);
  }
  template <class Protocol>
  static uint32_t serializedSizeZC(Protocol* prot, const Type* value) {
    return value->serializedSizeZC(prot);
  }
};

template <>
class Cpp2Ops<facebook::memcache::McGatRequest> {
 public:
  typedef facebook::memcache::McGatRequest Type;
  static constexpr protocol::TType thriftType() {
    return protocol::T_STRUCT;
  }
  template <class Protocol>
  static uint32_t write(Protocol* prot, const Type* value) {
    return value->write(prot);
  }
  template <class Protocol>
  static void read(Protocol* prot, Type* value) {
    value->read(prot);
  }
  template <class Protocol>
  static uint32_t serializedSize(Protocol* prot, const Type* value) {
    return value->serializedSize(prot);
  }
  template <class Protocol>
  static uint32_t serializedSizeZC(Protocol* prot, const Type* value) {
    return value->serializedSizeZC(prot);
  }
};

template <>
class Cpp2Ops<facebook::memcache::McGatReply> {
 public:
  typedef facebook::memcache::McGatReply Type;
  static constexpr protocol::TType thriftType() {
    return protocol::T_STRUCT;
  }
  template <class Protocol>
  static uint32_t write(Protocol* prot, const Type* value) {
    return value->write(prot);
  }
  template <class Protocol>
  static void read(Protocol* prot, Type* value) {
    value->read(prot);
  }
  template <class Protocol>
  static uint32_t serializedSize(Protocol* prot, const Type* value) {
    return value->serializedSize(prot);
  }
  template <class Protocol>
  static uint32_t serializedSizeZC(Protocol* prot, const Type* value) {
    return value->serializedSizeZC(prot);
  }
};

template <>
class Cpp2Ops<facebook::memcache::McGatsRequest> {
 public:
  typedef facebook::memcache::McGatsRequest Type;
  static constexpr protocol::TType thriftType() {
    return protocol::T_STRUCT;
  }
  template <class Protocol>
  static uint32_t write(Protocol* prot, const Type* value) {
    return value->write(prot);
  }
  template <class Protocol>
  static void read(Protocol* prot, Type* value) {
    value->read(prot);
  }
  template <class Protocol>
  static uint32_t serializedSize(Protocol* prot, const Type* value) {
    return value->serializedSize(prot);
  }
  template <class Protocol>
  static uint32_t serializedSizeZC(Protocol* prot, const Type* value) {
    return value->serializedSizeZC(prot);
  }
};

template <>
class Cpp2Ops<facebook::memcache::McGatsReply> {
 public:
  typedef facebook::memcache::McGatsReply Type;
  static constexpr protocol::TType thriftType() {
    return protocol::T_STRUCT;
  }
  template <class Protocol>
  static uint32_t write(Protocol* prot, const Type* value) {
    return value->write(prot);
  }
  template <class Protocol>
  static void read(Protocol* prot, Type* value) {
    value->read(prot);
  }
  template <class Protocol>
  static uint32_t serializedSize(Protocol* prot, const Type* value) {
    return value->serializedSize(prot);
  }
  template <class Protocol>
  static uint32_t serializedSizeZC(Protocol* prot, const Type* value) {
    return value->serializedSizeZC(prot);
  }
};
} // namespace thrift
} // namespace apache
